home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 4 / The 640 Meg Shareware Studio CD-ROM Volume IV (Data Express)(1994).ISO / wp / ehp10.zip / CUR_WFCS.C < prev    next >
C/C++ Source or Header  |  1993-06-19  |  39KB  |  1,152 lines
  1. /******************************************************************************
  2. *
  3. * Modul      : cur_wfcs.c
  4. *
  5. * Funktionen : tab_to_spc (Tab in Anzahl Blanks wandeln)
  6. *              cals_pos (Position in der Eingabezeile berechnen)
  7. *              check_special (Testen, ob Zeichen Sonderzeichen ist)
  8. *              do_special (Sonderzeichen anzeigen)
  9. *              waddch (Zeichen im Fenster anzeigen)
  10. *              winsch (Zeichen im Fenster einfügen)
  11. *              wdelch (Zeichen aus Fenster löschen)
  12. *              werase (Fensterinhalt löschen)
  13. *              wmove (Cursor im Fenster setzen)
  14. *              wclrtoeol (Rest der Zeile löschen)
  15. *              wclrtobot (Rest des Fensters löschen)
  16. *              wdeleteln (Zeile im Fenster löschen)
  17. *              winsertln (Zeile in Fenster einfügen)
  18. *              nodelay (Delay-Flag setzen/löschen)
  19. *              scrollok (Scroll-Modus setzen)
  20. *              leaveok (Cursor unsichtbar machen)
  21. *              wattrset (Attribut für anzuzeigende Zeichen setzen)
  22. *              wattron (Attribut für anzuzeigende Zeichen einschalten)
  23. *              wattroff (Attribut für anzuzeigende Zeichen ausschalten)
  24. *              waddstr (String im Fenster anzeigen)
  25. *              wgetstr (String einlesen)
  26. *              wprintw_body (Rumpf für Text formatiert im Fenster ausgeben)
  27. *              wscanw_body (Rumpf für Daten aus Fenster einlesen)
  28. *              wprintw (Text formatiert im Fenster ausgeben)
  29. *              wscanw (Daten aus Fenster einlesen)
  30. *              mvwprintw (Text formatiert an Position X/Y im Fenster ausgeben)
  31. *              mvwscanw (Daten an bestimmter Stelle im Fenster einlesen)
  32. *              box (Rahmen in Fenster zeichnen)
  33. *              winch (Zeichen aus Fenster lesen)
  34. *
  35. ******************************************************************************/
  36.  
  37. #include "curses.h"
  38. #include <stdarg.h>
  39.  
  40. void waddch (WINDOW*, short int), wdelch (WINDOW*);
  41.  
  42. extern char buffer[],*p_in,*p_out;
  43. extern short int *cur_to_poi();
  44. extern char rawflag,nlflag;
  45.  
  46. /******************************************************************************
  47. *
  48. * Funktion     : Tab in Anzahl Blanks wandeln (tab_to_spc)
  49. * --------------
  50. *
  51. * Parameter    : pos         :
  52. *                  Typ          : int
  53. *                  Wertebereich : 0-BUFF_SIZE
  54. *                  Bedeutung    : Position des Cursors relativ zum Beginn
  55. *                                 der Eingabe
  56. *
  57. * Ergebnis     :
  58. *                  Typ          : int
  59. *                  Wertebereich : 1-8
  60. *                  Bedeutung    : Anzahl der Blanks, die eingefügt werden
  61. *                                 müssen, um zur nächsten Tab-Grenze zu kommen
  62. *
  63. * Beschreibung : Es wird die Differenz zwischen der aktuellen relativen Po-
  64. *                sition zum Beginn der Eingabe und der nächsten Tab-Grenze
  65. *                berechnet und zurückgegeben.
  66. *
  67. ******************************************************************************/
  68.  
  69. int tab_to_spc(pos)
  70. int pos;
  71. {
  72.   return(8-(pos % 8)); /* Anzahl der Blanks, die zum Auffüllen bis */
  73. }                  /* zur nächsten Tab-Grenze erforderlich sind, zurückgeben */
  74.  
  75. /******************************************************************************
  76. *
  77. * Funktion     : Position in der Eingabezeile berechnen (calc_pos)
  78. * --------------
  79. *
  80. * Parameter    : start       :
  81. *                  Typ          : int
  82. *                  Wertebereich : 0-COLS
  83. *                  Bedeutung    : Position des Eingabestarts
  84. *
  85. * Ergebnis     :
  86. *                  Typ          : int
  87. *                  Wertebereich : 0 - BUFF_SIZE-1
  88. *                  Bedeutung    : Position des Cursors relativ zum Beginn der
  89. *                                 Eingabe
  90. *
  91. * Beschreibung : Der Eingabepuffer wird von Anfang an Zeichen für Zeichen
  92. *                durchgegangen. Dabei erhöht sich für jedes normale Zeichen
  93. *                der Rückgabewert um 1. Handelt es sich jedoch um einen Tab,
  94. *                so wird mit der Funktion tab_to_spc berechnet, wieviele Blanks
  95. *                eingefügt werden mußten und das Ergebnis um diese Anzahl er-
  96. *                höht.
  97. *
  98. ******************************************************************************/
  99.  
  100. int calc_pos(start)
  101. int start;
  102. {
  103.   int i = start;
  104.   char *hilf = buffer; /* Hilfszeiger in Puffer */
  105.  
  106.   while(hilf != p_in)
  107.   {
  108.     if(*hilf != '\t')
  109.       i++;
  110.     else
  111.       i += tab_to_spc(i);
  112.     hilf++;
  113.   }
  114.   return(i-start);
  115. }
  116.  
  117. /******************************************************************************
  118. *
  119. * Funktion     : Testen, ob Zeichen Sonderzeichen ist (check_special)
  120. * --------------
  121. *
  122. * Parameter    : c           :
  123. *                  Typ          : char
  124. *                  Wertebereich : '\0'-'\255'
  125. *                  Bedeutung    : Zu testendes Zeichen
  126. *
  127. * Ergebnis     :
  128. *                  Typ          : int
  129. *                  Wertebereich : TRUE, FALSE
  130. *                  Bedeutung    : TRUE=Sonderzeichen, FALSE=kein Sonderzeichen
  131. *
  132. * Beschreibung : Das Zeichen wird auf Newline, Backspace und Tab getestet. Ist
  133. *                es in dieser Gruppe, so wird TRUE, sonst FALSE zurückgegeben.
  134. *
  135. ******************************************************************************/
  136.  
  137. int check_special(c)
  138. char c;
  139. {
  140.   switch(c)
  141.   {
  142.     case '\n':
  143.     case '\b':
  144.     case '\t':
  145.       return(TRUE);
  146.     default:
  147.       return(FALSE);
  148.   }
  149. }
  150.  
  151. /******************************************************************************
  152. *
  153. * Funktion     : Sonderzeichen anzeigen (do_special)
  154. * --------------
  155. *
  156. * Parameter    : w           :
  157. *                  Typ          : WINDOW *
  158. *                  Wertebereich : Pointer auf WINDOW-Struktur
  159. *                  Bedeutung    : Fenster, in dem das Zeichen angezeigt werden
  160. *                                 soll
  161. *
  162. *              : c           :
  163. *                  Typ          : char
  164. *                  Wertebereich : '\0'-'\255'
  165. *                  Bedeutung    : Anzuzeigendes Zeichen
  166. *
  167. * Ergebnis     :
  168. *                  Typ          : int
  169. *                  Wertebereich : TRUE, FALSE
  170. *                  Bedeutung    : TRUE : Es handelte sich um ein Sonderzeichen
  171. *                                 FALSE: Es war ein normales Zeichen
  172. *
  173. * Beschreibung : Es wird getestet, ob das Zeichen ein Newline, ein Backspace
  174. *                oder ein Tab ist. Ist dem so, wird die entsprechende Sonder-
  175. *                behandlung vorgenommen und der Wert TRUE zurückgegeben. An-
  176. *                sonsten wird FALSE zurückgegeben.
  177. *
  178. ******************************************************************************/
  179.  
  180. int do_special(w,c)
  181. WINDOW *w;
  182. char c;
  183. {
  184.   int i;
  185.  
  186.   switch(c)
  187.   {
  188.     case '\r':          /* *** Carriage return *** */
  189.       w->_cursor_x = 0;
  190.       break;
  191.     case '\n':          /* *** newline  *** */
  192.       if(nlflag)  /* Nur X auf 0, falls \n in CR-LF umgewandelt werden soll */
  193.     w->_cursor_x = 0;
  194.       if(w->_cursor_y < w->_width_y-1)
  195.     w->_cursor_y++;
  196.       else
  197.     if(w->_scrflag)
  198.       scroll(w);
  199.       return(TRUE);
  200.     case '\b':          /* *** backspace *** */
  201.       if(w->_cursor_x)   /* Steht Cursor auch nicht in der ersten Spalte ? */
  202.       {
  203.     w->_cursor_x--;
  204.     wdelch(w);
  205.       }
  206.       else              /* Wenn Cursor doch in erster Spalte, dann, falls es */
  207.       {                 /* eine darüberliegende Zeile gibt, deren letztes    */
  208.     if(w->_cursor_y) /* Zeichen löschen */
  209.     {
  210.       w->_cursor_x = w->_width_x-1;
  211.       w->_cursor_y--;
  212.       wdelch(w);
  213.     }
  214.       }
  215.       return(TRUE);
  216.     case '\t':          /* *** tab *** */
  217.       if(w->_tabflag)
  218.       {
  219.     for(i=tab_to_spc(w->_cursor_x) ; i ; i--)
  220.       waddch(w,' ');
  221.     return(TRUE);
  222.       }
  223.       else
  224.     return(FALSE);
  225.     default:
  226.       return(FALSE);
  227.   }
  228. }
  229.  
  230. /******************************************************************************
  231. *
  232. * Funktion     : Zeichen im Fenster anzeigen (waddch)
  233. * --------------
  234. *
  235. * Parameter    : w           :
  236. *                  Typ          : WINDOW *
  237. *                  Wertebereich : Pointer auf WINDOW-Struktur
  238. *                  Bedeutung    : Fenster, in dem das Zeichen angezeigt werden
  239. *                                 soll
  240. *
  241. *              : c           :
  242. *                  Typ          : short int
  243. *                  Wertebereich : ('\0'-'\255') [ +256*<Attribut> ]
  244. *                  Bedeutung    : Anzuzeigendes Zeichen, evtl. mit Attribut
  245. *
  246. * Beschreibung : In der Funktion do_special wird getestet, ob es sich bei
  247. *                dem anzuzeigenden Zeichen um ein Sonderzeichen handelt. Falls
  248. *                ja, wird dort die Behandlung vorgenommen. Ansonsten wird das
  249. *                Zeichen ins Window-Image geschrieben und die Cursorposition
  250. *                angepasst. Nötigenfalls wird der Fensterinhalt gescrollt.
  251. *
  252. ******************************************************************************/
  253.  
  254. void waddch(w,c)
  255. WINDOW *w;
  256. short int c;
  257. {
  258.   if(!do_special(w,c & 255)) /* Testen, ob Zeichen ein Sonderzeichen war */
  259.   {
  260.     if(c>>8)  /* Attribute wurden mit dem Zeichen mitgegeben ? */
  261.     {
  262. #ifdef CUR_DIRECT
  263.       VioWrtNCell (&c, 1, w->_start_y+w->_cursor_y,
  264.            w->_start_x+w->_cursor_x, 0);
  265. #endif
  266.       *cur_to_poi(w) = c;
  267.     }
  268.     else
  269.     {
  270.       if(w->_attribs) /* Irgendwelche Attribute gesetzt ? */
  271.     c = c | (w->_attribs*256);
  272.       else
  273.     c = c | (STD_ATTR*256);
  274. #ifdef CUR_DIRECT
  275.       VioWrtNCell (&c, 1, w->_start_y+w->_cursor_y,
  276.              w->_start_x+w->_cursor_x, 0);
  277. #endif
  278.       *cur_to_poi(w) = c;
  279.     }
  280.     cur_right(w,1);
  281.   }
  282. }
  283.  
  284. /******************************************************************************
  285. *
  286. * Funktion     : Zeichen im Fenster einfügen (winsch)
  287. * --------------
  288. *
  289. * Parameter    : w           :
  290. *                  Typ          : WINDOW *
  291. *                  Wertebereich : Pointer auf WINDOW-Struktur
  292. *                  Bedeutung    : Fenster, in dem das Zeichen eingefügt werden
  293. *                                 soll
  294. *
  295. *              : c           :
  296. *                  Typ          : short int
  297. *                  Wertebereich : '\0'-'\255'
  298. *                  Bedeutung    : Anzuzeigendes Zeichen
  299. *
  300. * Beschreibung : In der aktuellen Zeile im Window-Image wird für das ein-
  301. *                zufügende Zeichen Platz geschaffen, falls es sich nicht um
  302. *                Newline oder Backspace handelt. Bei einem Tab wird die
  303. *                korrekte Anzahl bis zur nächsten Tab-Grenze eingefügt.
  304. *                Anschliessend wird die Funktion waddch aufgerufen, die
  305. *                das Zeichen einfügt, bzw. das Sonderzeichen ausführt.
  306. *
  307. ******************************************************************************/
  308.  
  309. void winsch(w,c)
  310. WINDOW *w;
  311. short int c;
  312. {
  313.   short int *s,*d,anz_copy, anz_copy_si, anz_ins=1;
  314. #ifdef CUR_DIRECT
  315.   short int *buffer;
  316. #endif
  317.  
  318.   if(!check_special(c & 255)) /* Nur Platz schaffen, falls kein Sonderzeichen */
  319.   {
  320.     if((c & 255) == '\t') /* Bei Tab müssen mehrere Zeichen eingefügt werden */
  321.       anz_ins = 8*(w->_cursor_x/8 + 1);
  322.     /* Anzahl zu kopierender Zeichen bestimmen */
  323.     anz_copy = w->_width_x - w->_cursor_x - anz_ins;
  324.     if(anz_copy_si = sizeof(short int) * anz_copy)
  325.     {
  326. #ifdef CUR_DIRECT
  327.       buffer = (short int*) malloc (anz_copy_si);
  328.       VioReadCellStr (buffer, &anz_copy_si, w->_start_y+w->_cursor_y,
  329.               w->_start_x+w->_cursor_x, 0);
  330.       VioWrtCellStr (buffer, anz_copy_si, w->_start_y+w->_cursor_y,
  331.              w->_start_x+w->_cursor_x+anz_ins, 0);
  332.       free (buffer);
  333. #endif
  334.       s = cur_to_poi(w)+anz_copy-1; /* Zeiger auf aktuelles Zeichen */
  335.       d = s+anz_ins;
  336.       while(anz_copy--)
  337.     *d-- = *s--;
  338.     }
  339.   }
  340.   waddch(w,c);
  341. }
  342.  
  343. /******************************************************************************
  344. *
  345. * Funktion     : Zeichen aus Fenster löschen (wdelch)
  346. * --------------
  347. *
  348. * Parameter    : w           :
  349. *                  Typ          : WINDOW *
  350. *                  Wertebereich : Pointer auf WINDOW-Struktur
  351. *                  Bedeutung    : Fenster, aus dem Zeichen gelöscht werden soll
  352. *
  353. * Beschreibung : Alle Zeichen, die in der Cursorzeile rechts des Cursors
  354. *                stehen, werden um 1 nach links bewegt. Anschliessend wird
  355. *                das letzte Zeichen der Zeile gelöscht.
  356. *
  357. ******************************************************************************/
  358.  
  359. void wdelch(w)
  360. WINDOW *w;
  361. {
  362.   short int *d,old_x = w->_cursor_x;
  363.   char      c=256*STD_ATTR; /* zum Löschen rechts am Rand */
  364. #ifdef CUR_DIRECT
  365.   short int *buffer;        /* Puffer für zu verschiebende Zeichen */
  366.   int       anz_copy;       /* Anzahl zu verschiebender Zeichen */
  367. #endif
  368.  
  369.   d = cur_to_poi(w); /* Zeichen, auf dem der Cursor steht, merken */
  370.   if (w->_cursor_x < w->_width_x-1) /* Steht Cursor nicht am rechten Rand ? */
  371.   {
  372. #ifdef CUR_DIRECT
  373.     anz_copy = (w->_width_x-1-w->_cursor_x)*sizeof (short int);
  374.     buffer = (short int*) malloc (anz_copy*sizeof(short int));
  375.     VioReadCellStr (buffer, &anz_copy, w->_start_y+w->_cursor_y,
  376.             w->_start_x+w->_cursor_x+1, 0);
  377.     VioWrtCellStr (buffer, anz_copy, w->_start_y+w->_cursor_y,
  378.            w->_start_x+w->_cursor_x, 0);
  379.     free (buffer);
  380. #endif
  381.     memcpy(d,d+1,(w->_width_x - w->_cursor_x - 1)*sizeof(short int));
  382.   }
  383.   w->_cursor_x = w->_width_x-1;
  384. #ifdef CUR_DIRECT
  385.   VioWrtNCell (&c, 1, w->_start_y+w->_cursor_y,
  386.            w->_start_x+w->_cursor_x, 0);
  387. #endif
  388.   *cur_to_poi(w) = c; /* Letztes Zeichen in der Zeile löschen */
  389.   w->_cursor_x = old_x;
  390. }
  391.  
  392. /******************************************************************************
  393. *
  394. * Funktion     : Fensterinhalt löschen (werase)
  395. * --------------
  396. *
  397. * Parameter    : w           :
  398. *                  Typ          : WINDOW *
  399. *                  Wertebereich : Pointer auf WINDOW-Struktur
  400. *                  Bedeutung    : Fenster, dessen Inhalt gelöscht werden soll
  401. *
  402. * Beschreibung : Der Inhalt des Window-Images des angegebenen Fensters wird
  403. *                mit dem Standardattribut überschrieben, also gelöscht.
  404. *
  405. ******************************************************************************/
  406.  
  407. void werase(w)
  408. WINDOW *w;
  409. {
  410.   short int *d,i;
  411. #ifdef CUR_DIRECT
  412.   short int c = STD_ATTR*256;
  413.   int   line;
  414.  
  415.   for (line=w->_start_y; line < w->_start_y+w->_width_y; line++)
  416.     VioWrtNCell (&c, w->_width_x, line, w->_start_x, 0);
  417. #endif
  418.   for (d = w->_image , i=w->_width_y*w->_width_x ; i ; i-- , d++)
  419.     *d = STD_ATTR*256;   /* Bildschirm löschen */
  420. }
  421.  
  422. /******************************************************************************
  423. *
  424. * Funktion     : Cursor im Fenster setzen (wmove)
  425. * --------------
  426. *
  427. * Parameter    : w           :
  428. *                  Typ          : WINDOW *
  429. *                  Wertebereich : Pointer auf WINDOW-Struktur
  430. *                  Bedeutung    : Fenster, dessen Cursor gesetzt werden soll
  431. *
  432. *              : y           :
  433. *                  Typ          : short int
  434. *                  Wertebereich : 0 - w->_width_y-1
  435. *                  Bedeutung    : Neue Y-Position des Cursors
  436. *
  437. *              : x           :
  438. *                  Typ          : short int
  439. *                  Wertebereich : 0 - w->_width_x-1
  440. *                  Bedeutung    : Neue X-Position der Cursors
  441. *
  442. * Beschreibung : Falls die Angegebenen Koordinaten innerhalb des Fenster
  443. *                liegen, werden wie Werte cursor_x und cursor_y angepasst.
  444. *
  445. ******************************************************************************/
  446.  
  447. void wmove(w,y,x)
  448. WINDOW *w;
  449. short int y,x;
  450. {
  451.   if(y>=0 && y<w->_width_y && x>=0 && x<w->_width_x)
  452.   {
  453.     w->_cursor_x = x;
  454.     w->_cursor_y = y;
  455.   }
  456. }
  457.  
  458. /******************************************************************************
  459. *
  460. * Funktion     : Rest der Zeile löschen (wclrtoeol)
  461. * --------------
  462. *
  463. * Parameter    : w           :
  464. *                  Typ          : WINDOW *
  465. *                  Wertebereich : Pointer auf WINDOW-Struktur
  466. *                  Bedeutung    : Fenster, in dem Rest der Cursorzeile
  467. *                                 gelöscht werden soll.
  468. *
  469. * Beschreibung : Ab der Cursorposition bis zum Zeilenende wird alles mit
  470. *                dem Standardattribut besetzt, also gelöscht.
  471. *
  472. ******************************************************************************/
  473.  
  474. void wclrtoeol(w)
  475. WINDOW *w;
  476. {
  477.   short int *p,i;
  478. #ifdef CUR_DIRECT
  479.   short int c = 256*STD_ATTR;
  480.  
  481.   VioWrtNCell (&c, w->_width_x-w->_cursor_x, w->_start_y+w->_cursor_y,
  482.            w->_start_x+w->_cursor_x, 0);
  483. #endif
  484.   for(p=cur_to_poi(w) , i=w->_width_x-w->_cursor_x ; i ; p++ , i--)
  485.     *p = STD_ATTR*256;
  486. }
  487.  
  488. /******************************************************************************
  489. *
  490. * Funktion     : Rest der Fensters löschen (wclrtobot)
  491. * --------------
  492. *
  493. * Parameter    : w           :
  494. *                  Typ          : WINDOW *
  495. *                  Wertebereich : Pointer auf WINDOW-Struktur
  496. *                  Bedeutung    : Fenster, in dem Rest ab Cursorposition
  497. *                                 gelöscht werden soll.
  498. *
  499. * Beschreibung : Ab der Cursorposition bis zum Zeilenende und in allen Zeilen
  500. *                unter der aktuellen Cursorzeile wird alles mit
  501. *                dem Standardattribut besetzt, also gelöscht.
  502. *
  503. ******************************************************************************/
  504.  
  505. void wclrtobot(w)
  506. WINDOW *w;
  507. {
  508.   short int *p, *end=w->_image+w->_width_x*w->_width_y;
  509. #ifdef CUR_DIRECT
  510.   short int c = STD_ATTR*256;
  511.   int   line;
  512.  
  513.   wclrtoeol(w);
  514.   for (line=w->_start_y+w->_cursor_y+1; line < w->_start_y+w->_width_y; line++)
  515.     VioWrtNCell (&c, w->_width_x, line, w->_start_x, 0);
  516. #endif
  517.   for(p=cur_to_poi(w) ; p < end ; p++)
  518.     *p = STD_ATTR*256;
  519. }
  520.  
  521. /******************************************************************************
  522. *
  523. * Funktion     : Zeile im Fenster löschen (wdeleteln)
  524. * --------------
  525. *
  526. * Parameter    : w           :
  527. *                  Typ          : WINDOW *
  528. *                  Wertebereich : Pointer auf WINDOW-Struktur
  529. *                  Bedeutung    : Fenster, in dem Zeile gelöscht werden soll
  530. *
  531. * Beschreibung : Alle Zeilen hinter der, in der der Cursor steht, werden um
  532. *                eine Zeile nach oben kopiert. Die letzte Zeile des Fensters
  533. *                wird mit dem Standard-Attribut besetzt, also gelöscht.
  534. *
  535. ******************************************************************************/
  536.  
  537. void wdeleteln(w)
  538. WINDOW *w;
  539. {
  540.   short int i,*d = w->_image + w->_width_x*w->_cursor_y;
  541. #ifdef CUR_DIRECT
  542.   short int c = 256*STD_ATTR;
  543. #endif
  544.  
  545.   if(w->_cursor_y < w->_width_y-1) /* Cursor vor letzter Zeile ? */
  546.   {
  547. #ifdef CUR_DIRECT
  548.     VioScrollUp (w->_start_y+w->_cursor_y, w->_start_x,
  549.          w->_start_y+w->_width_y-1, w->_start_x+w->_width_x-1,
  550.          1, &c, 0);
  551. #endif
  552.     memcpy(d,d+w->_width_x,w->_width_x*(w->_width_y-w->_cursor_y-1)*sizeof(short int));
  553.   }
  554.   for(d=w->_image+w->_width_x*(w->_width_y-1) , i=w->_width_x ; i ; i-- , d++)
  555.     *d = STD_ATTR*256; /* letzte Zeile löschen */
  556. }
  557.  
  558. /******************************************************************************
  559. *
  560. * Funktion     : Zeile in Fenster einfügen (winsertln)
  561. * --------------
  562. *
  563. * Parameter    : w           :
  564. *                  Typ          : WINDOW *
  565. *                  Wertebereich : Pointer auf WINDOW-Struktur
  566. *                  Bedeutung    : Fenster, in dem eine Zeile eingefügt wird
  567. *
  568. * Beschreibung : Alle Zeilen inklusive der aktuellen werden um eine Zeile nach
  569. *                unten kopiert. Anschließend wird die aktuelle Zeile gelöscht.
  570. *
  571. ******************************************************************************/
  572.  
  573. void winsertln(w)
  574. WINDOW *w;
  575. {
  576.   short int i,*d,*s,n;
  577. #ifdef CUR_DIRECT
  578.   short int c = 256*STD_ATTR;
  579. #endif
  580.  
  581.   if(w->_cursor_y < w->_width_y-1) /* Cursor nicht vor letzter Zeile ? */
  582.   {
  583. #ifdef CUR_DIRECT
  584.     VioScrollDn (w->_start_y+w->_cursor_y, w->_start_x,
  585.          w->_start_y+w->_width_y-1, w->_start_x+w->_width_x-1,
  586.          1, &c, 0);
  587. #endif
  588.     n = w->_width_x*(w->_width_y-w->_cursor_y-1); /* Anzahl short ints */
  589.     d = w->_image + w->_width_x * (w->_cursor_y+1) + n; /* Destination */
  590.     s = w->_image + w->_width_x * w->_cursor_y + n; /* Source */
  591.     while(n--)
  592.       *--d = *--s; /* Zeilen kopieren */
  593.   }
  594.   for(d=w->_image+w->_width_x*w->_cursor_y , i=w->_width_x ; i ; i-- , d++)
  595.     *d = STD_ATTR*256; /* aktuelle Zeile löschen */
  596. }
  597.  
  598. /******************************************************************************
  599. *
  600. * Funktion     : Delay-Flag setzen (nodelay)
  601. * --------------
  602. *
  603. * Parameter    : w           :
  604. *                  Typ          : WINDOW *
  605. *                  Wertebereich : Pointer auf WINDOW-Struktur
  606. *                  Bedeutung    : Fenster, für das das delay-Flag manipuliert
  607. *                                 werden soll
  608. *
  609. *              : d           :
  610. *                  Typ          : char
  611. *                  Wertebereich : TRUE, FALSE
  612. *                  Bedeutung    : Gewünschter Zustand des delay-Flags
  613. *
  614. * Beschreibung : dlyflag wird auf d gesetzt.
  615. *
  616. ******************************************************************************/
  617.  
  618. void nodelay(w,d)
  619. WINDOW *w;
  620. char d;
  621. {
  622.   w->_dlyflag = !d;
  623. }
  624.  
  625. /******************************************************************************
  626. *
  627. * Funktion     : Scroll-Modus setzen (scrollok)
  628. * --------------
  629. *
  630. * Parameter    : w           :
  631. *                  Typ          : WINDOW *
  632. *                  Wertebereich : Pointer auf WINDOW-Struktur
  633. *                  Bedeutung    : Fenster, für das der scroll-mode manipuliert
  634. *                                 werden soll
  635. *
  636. *              : s           :
  637. *                  Typ          : char
  638. *                  Wertebereich : TRUE, FALSE
  639. *                  Bedeutung    : Gewünschter Zustand des scroll-Flags
  640. *
  641. * Beschreibung : Das scroll-Flag wird auf s gesetzt.
  642. *
  643. ******************************************************************************/
  644.  
  645. void scrollok(w,s)
  646. WINDOW *w;
  647. char s;
  648. {
  649.   w->_scrflag = s;
  650. }
  651.  
  652. /******************************************************************************
  653. *
  654. * Funktion     : Leavok-Modus setzen (leaveok)
  655. * --------------
  656. *
  657. * Parameter    : w           :
  658. *                  Typ          : WINDOW *
  659. *                  Wertebereich : Pointer auf WINDOW-Struktur
  660. *                  Bedeutung    : Fenster, für das der leaveok-mode manipuliert
  661. *                                 werden soll
  662. *
  663. *              : f           :
  664. *                  Typ          : char
  665. *                  Wertebereich : TRUE, FALSE
  666. *                  Bedeutung    : Gewünschter Zustand des leaveok-Flags
  667. *
  668. * Beschreibung : Das leaveok-Flag wird auf s gesetzt.
  669. *
  670. ******************************************************************************/
  671.  
  672. void leaveok(w,f)
  673. WINDOW *w;
  674. char f;
  675. {
  676.   w->_lvokflag = f;
  677. }
  678.  
  679. /******************************************************************************
  680. *
  681. * Funktion     : Attribut für anzuzeigende Zeichen setzen (wattrset)
  682. * --------------
  683. *
  684. * Parameter    : w           :
  685. *                  Typ          : WINDOW *
  686. *                  Wertebereich : Pointer auf WINDOW-Struktur
  687. *                  Bedeutung    : Fenster, für das Attribute manipuliert
  688. *                                 werden sollen
  689. *
  690. *              : a           :
  691. *                  Typ          : short int
  692. *                  Wertebereich : 256 * (0 - 255)
  693. *                  Bedeutung    : Neues Attribut
  694. *
  695. * Beschreibung : Die Attribute fuer Fenster w werden auf a gesetzt.
  696. *
  697. ******************************************************************************/
  698.  
  699. void wattrset(w,a)
  700. WINDOW *w;
  701. short int a;
  702. {
  703.   w->_attribs = a;
  704. }
  705.  
  706. /******************************************************************************
  707. *
  708. * Funktion     : Attribut für anzuzeigende Zeichen einschalten (wattron)
  709. * --------------
  710. *
  711. * Parameter    : w           :
  712. *                  Typ          : WINDOW *
  713. *                  Wertebereich : Pointer auf WINDOW-Struktur
  714. *                  Bedeutung    : Fenster, für das Attribute manipuliert
  715. *                                 werden sollen
  716. *
  717. *              : a           :
  718. *                  Typ          : short int
  719. *                  Wertebereich : 256 * (0 - 255)
  720. *                  Bedeutung    : einzuschaltendes Attribut
  721. *
  722. * Beschreibung : Zum attribs des Fensters w wird a dazugeodert.
  723. *
  724. ******************************************************************************/
  725.  
  726. void wattron(w,a)
  727. WINDOW *w;
  728. short int a;
  729. {
  730.   w->_attribs |= a;
  731. }
  732.  
  733. /******************************************************************************
  734. *
  735. * Funktion     : Attribut für anzuzeigende Zeichen ausschalten (wattroff)
  736. * --------------
  737. *
  738. * Parameter    : w           :
  739. *                  Typ          : WINDOW *
  740. *                  Wertebereich : Pointer auf WINDOW-Struktur
  741. *                  Bedeutung    : Fenster, für das Attribute manipuliert
  742. *                                 werden sollen
  743. *
  744. *              : a           :
  745. *                  Typ          : short int
  746. *                  Wertebereich : 256 * (0 - 255)
  747. *                  Bedeutung    : auszuschaltendes Attribut
  748. *
  749. * Beschreibung : Vom attribs des Fensters w wird a weggeandet.
  750. *
  751. ******************************************************************************/
  752.  
  753. void wattroff(w,a)
  754. WINDOW *w;
  755. short int a;
  756. {
  757.   w->_attribs &= ~a;
  758. }
  759.  
  760. /******************************************************************************
  761. *
  762. * Funktion     : String im Fenster anzeigen (waddstr)
  763. * --------------
  764. *
  765. * Parameter    : w           :
  766. *                  Typ          : WINDOW *
  767. *                  Wertebereich : Pointer auf WINDOW-Struktur
  768. *                  Bedeutung    : Fenster, in dem der String angeiezgt werden
  769. *                                 soll
  770. *
  771. *              : s           :
  772. *                  Typ          : char *
  773. *                  Wertebereich : Zeiger auf ASCII-Zeichenkette
  774. *                  Bedeutung    : Anzuzeigender String
  775. *
  776. * Beschreibung : Jedes Zeichen des String wird der Funktion waddch übergeben
  777. *
  778. ******************************************************************************/
  779.  
  780. void waddstr(w,s)
  781. WINDOW *w;
  782. char *s;
  783. {
  784.   if(s)
  785.     while(*s)
  786.       waddch(w,(unsigned short int) *s++);
  787. }
  788.  
  789. /******************************************************************************
  790. *
  791. * Funktion     : String einlesen (wgetstr)
  792. * --------------
  793. *
  794. * Parameter    : w           :
  795. *                  Typ          : WINDOW *
  796. *                  Wertebereich : Pointer auf WINDOW-Struktur
  797. *                  Bedeutung    : Fenster, in dem eingelesene Zeichen evtl.
  798. *                                 angezeigt werden sollen
  799. *
  800. *              : s           :
  801. *                  Typ          : char *
  802. *                  Wertebereich : Pointer auf reservierten Speicherbereich
  803. *                  Bedeutung    : Platz, wohin der String gelesen werden soll
  804. *
  805. * Ergebnis     :
  806. *                  Typ          : char *
  807. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  808. *                  Bedeutung    : Eingelesener String, identisch mit s
  809. *
  810. * Beschreibung : Es wird wgetch aufgerufen und das eingelesene Zeichen an den
  811. *                bisher eingelesenen String angehängt. Ist das Zeichen '\n',
  812. *                so bricht die Schleife ab, das '\n' wird durch '\0' ersetzt.
  813. *                Der Pointer auf den Anfang des eingelesenen Strings wird
  814. *                zurückgegeben.
  815. *
  816. ******************************************************************************/
  817.  
  818. char *wgetstr(w,s)
  819. WINDOW *w;
  820. char *s;
  821. {
  822.   char *c = s,old_raw = rawflag;
  823.  
  824.   rawflag = FALSE; /* Strings werden stets im cooked-Mode eingelesen */
  825.   do
  826.     *c++ = (char) wgetch(w);
  827.   while((c[-1] != '\n' && nlflag) || (c[-1] != '\r' && !nlflag));
  828.   *(--c) = '\0'; /* Newline durch NULL-Charakter ersetzen */
  829.   rawflag = old_raw;
  830.   return(s);
  831. }
  832.  
  833. /******************************************************************************
  834. *
  835. * Funktion     : Rumpf für Text formatiert im Fenster ausgeben (wprintw_body)
  836. * --------------
  837. *
  838. * Parameter    : w           :
  839. *                  Typ          : WINDOW *
  840. *                  Wertebereich : Pointer auf WINDOW-Struktur
  841. *                  Bedeutung    : Fenster, in das Text kommen soll
  842. *
  843. *              : format      :
  844. *                  Typ          : char *
  845. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  846. *                  Bedeutung    : Formatstring (wie bei printf)
  847. *
  848. *              : param       :
  849. *                  Typ          : va_list
  850. *                  Wertebereich : Pointer auf Parameter
  851. *                  Bedeutung    : Liste auszugebender Werte
  852. *
  853. * Beschreibung : Der Formatstring wird zusammen mit dem Pointer auf die
  854. *                Parameterliste an vsprintf übergeben. Der mit vsprintf
  855. *                erzeugte String wird mit waddstr in das gewünschte
  856. *                Fenster ausgegeben.
  857. *
  858. ******************************************************************************/
  859.  
  860. void wprintw_body(w,format,param)
  861. WINDOW *w;
  862. char *format;
  863. va_list param;
  864. {
  865.   char buff[BUFF_SIZE+1];
  866.  
  867.   vsprintf(buff,format,param);
  868.   waddstr(w,buff);
  869. }
  870.  
  871. /******************************************************************************
  872. *
  873. * Funktion     : Rumpf für Daten aus Fenster einlesen (wscanw_body)
  874. * --------------
  875. *
  876. * Parameter    : w           :
  877. *                  Typ          : WINDOW *
  878. *                  Wertebereich : Pointer auf WINDOW-Struktur
  879. *                  Bedeutung    : Fenster, in das Text kommen soll
  880. *
  881. *              : format      :
  882. *                  Typ          : char *
  883. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  884. *                  Bedeutung    : Formatstring (wie bei scanf)
  885. *
  886. *              : param       :
  887. *                  Typ          : va_list
  888. *                  Wertebereich : Pointer auf Parameter
  889. *                  Bedeutung    : Adressen einzulesender Variablen
  890. *
  891. * Beschreibung : Mit wgetstr wird ein String eingelesen. Anschließend werden
  892. *                Über die Funktion vsscanf die Variablen richtig besetzt.
  893. *
  894. ******************************************************************************/
  895.  
  896. void wscanw_body(w,format,param)
  897. WINDOW *w;
  898. char *format;
  899. va_list param;
  900. {
  901.   char buff[BUFF_SIZE+1];
  902.  
  903.   wgetstr(w,buff);
  904.   vsscanf(buff,format,param);
  905. }
  906.  
  907. /******************************************************************************
  908. *
  909. * Funktion     : Text formatiert im Fenster ausgeben (wprintw)
  910. * --------------
  911. *
  912. * Parameter    : w           :
  913. *                  Typ          : WINDOW *
  914. *                  Wertebereich : Pointer auf WINDOW-Struktur
  915. *                  Bedeutung    : Fenster, in das Text kommen soll
  916. *
  917. *              : format      :
  918. *                  Typ          : char *
  919. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  920. *                  Bedeutung    : Formatstring (wie bei printf)
  921. *
  922. *              : ...         :
  923. *                  Typ          : Parameterliste
  924. *                  Wertebereich : ???
  925. *                  Bedeutung    : Liste auszugebender Werte
  926. *
  927. * Beschreibung : Über va_start wird der Pointer auf den ersten Parameter
  928. *                ermittelt. Dann wird wprintw_body aufgerufen.
  929. *
  930. ******************************************************************************/
  931.  
  932. void wprintw(WINDOW *w, char *format, ...)
  933. {
  934.   va_list param;
  935.  
  936.   va_start(param,format);
  937.   wprintw_body(w,format,param);
  938.   va_end(param);
  939. }
  940.  
  941. /******************************************************************************
  942. *
  943. * Funktion     : Daten aus Fenster einlesen (wscanw)
  944. * --------------
  945. *
  946. * Parameter    : w           :
  947. *                  Typ          : WINDOW *
  948. *                  Wertebereich : Pointer auf WINDOW-Struktur
  949. *                  Bedeutung    : Fenster, in das Text kommen soll
  950. *
  951. *              : format      :
  952. *                  Typ          : char *
  953. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  954. *                  Bedeutung    : Formatstring (wie bei scanf)
  955. *
  956. *              : ...         :
  957. *                  Typ          : Parameterliste
  958. *                  Wertebereich : ???
  959. *                  Bedeutung    : Adressen einzulesender Variablen
  960. *
  961. * Beschreibung : Der Anfang der Variablenliste wird mit va_start ermittelt.
  962. *                Dann wird wscanw_body aufgerufen.
  963. *
  964. ******************************************************************************/
  965.  
  966. void wscanw(WINDOW *w, char *format, ...)
  967. {
  968.   va_list param;
  969.  
  970.   va_start(param,format);
  971.   wscanw_body(w,format,param);
  972.   va_end(param);
  973. }
  974.  
  975. /******************************************************************************
  976. *
  977. * Funktion     : Text formatiert an Position X/Y im Fenster ausgeben(mvwprintw)
  978. * --------------
  979. *
  980. * Parameter    : w           :
  981. *                  Typ          : WINDOW *
  982. *                  Wertebereich : Pointer auf WINDOW-Struktur
  983. *                  Bedeutung    : Fenster, in das Text kommen soll
  984. *
  985. *              : y           :
  986. *                  Typ          : short int
  987. *                  Wertebereich : 0-LINES
  988. *                  Bedeutung    : Startposition für Ausgabe Y
  989. *
  990. *              : x           :
  991. *                  Typ          : short int
  992. *                  Wertebereich : 0-COLS
  993. *                  Bedeutung    : Startposition für Ausgabe X
  994. *
  995. *              : format      :
  996. *                  Typ          : char *
  997. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  998. *                  Bedeutung    : Formatstring (wie bei printf)
  999. *
  1000. *              : ...         :
  1001. *                  Typ          : Parameterliste
  1002. *                  Wertebereich : ???
  1003. *                  Bedeutung    : Liste auszugebender Werte
  1004. *
  1005. * Beschreibung : Über va_start wird der Pointer auf den ersten Parameter
  1006. *                ermittelt. Anschließend wird der Cursor an die gewünschte
  1007. *                Stelle bewegt. Dann wird wprintw_body aufgerufen.
  1008. *
  1009. ******************************************************************************/
  1010.  
  1011. void mvwprintw(WINDOW *w, short int y, short int x, char *format, ...)
  1012. {
  1013.   va_list param;
  1014.  
  1015.   va_start(param,format);
  1016.   wmove(w,y,x);
  1017.   wprintw_body(w,format,param);
  1018.   va_end(param);
  1019. }
  1020.  
  1021. /******************************************************************************
  1022. *
  1023. * Funktion     : Daten an bestimmter Stelle im Fenster einlesen (mvwscanw)
  1024. * --------------
  1025. *
  1026. * Parameter    : w           :
  1027. *                  Typ          : WINDOW *
  1028. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1029. *                  Bedeutung    : Fenster, in das Text kommen soll
  1030. *
  1031. *              : y           :
  1032. *                  Typ          : short int
  1033. *                  Wertebereich : 0-LINES
  1034. *                  Bedeutung    : Startposition für Eingabe Y
  1035. *
  1036. *              : x           :
  1037. *                  Typ          : short int
  1038. *                  Wertebereich : 0-COLS
  1039. *                  Bedeutung    : Startposition für Eingabe X
  1040. *
  1041. *              : format      :
  1042. *                  Typ          : char *
  1043. *                  Wertebereich : Pointer auf ASCII-Zeichenkette
  1044. *                  Bedeutung    : Formatstring (wie bei scanf)
  1045. *
  1046. *              : ...         :
  1047. *                  Typ          : Parameterliste
  1048. *                  Wertebereich : ???
  1049. *                  Bedeutung    : Adressen einzulesender Variablen
  1050. *
  1051. * Beschreibung : Der Anfang der Variablenliste wird mit va_start ermittelt.
  1052. *                Dann wird der Cursor an die richtige Stelle bewegt.
  1053. *                Dann wird wscanw_body aufgerufen.
  1054. *
  1055. ******************************************************************************/
  1056.  
  1057. void mvwscanw(WINDOW *w, short int y, short int x, char *format, ...)
  1058. {
  1059.   va_list param;
  1060.  
  1061.   va_start(param,format);
  1062.   wmove(w,y,x);
  1063.   wscanw_body(w,format,param);
  1064.   va_end(param);
  1065. }
  1066.  
  1067. /******************************************************************************
  1068. *
  1069. * Funktion     : Rahmen in Fenster zeichnen (box)
  1070. * --------------
  1071. *
  1072. * Parameter    : w           :
  1073. *                  Typ          : WINDOW *
  1074. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1075. *                  Bedeutung    : Fenster, in dem Rahmen erscheinen soll
  1076. *
  1077. *              : sr          :
  1078. *                  Typ          : char
  1079. *                  Wertebereich : '\0'-'\255'
  1080. *                  Bedeutung    : Zeichen für senkrechte Ränder
  1081. *
  1082. *              : wr          :
  1083. *                  Typ          : char
  1084. *                  Wertebereich : '\0'-'\255'
  1085. *                  Bedeutung    : Zeichen für waagerechte Ränder
  1086. *
  1087. * Beschreibung : In das angegebene Fenster wird ein Rahmen eingezeichnet.
  1088. *                Es wird kein Refresh vorgenommen.
  1089. *
  1090. ******************************************************************************/
  1091.  
  1092. void box(w,sr,wr)
  1093. WINDOW *w;
  1094. char sr,wr;
  1095. {
  1096.   int i;
  1097.   char old_scroll = w->_scrflag;
  1098.  
  1099.   w->_scrflag = FALSE; /* Fenster soll nicht scrollen, wenn unten rechts die */
  1100.   wmove(w,0,0);      /* Ecke eingezeichnet wird. */
  1101.   waddch(w,'┌');
  1102.   wmove(w,0,w->_width_x-1);
  1103.   waddch(w,'┐');
  1104.   wmove(w,w->_width_y-1,0);
  1105.   waddch(w,'└');
  1106.   wmove(w,w->_width_y-1,w->_width_x-1);
  1107.   waddch(w,'┘');
  1108.   for(i=1 ; i < w->_width_x-1 ; i++)
  1109.   {
  1110.     wmove(w,0,i);    /* Rand oben */
  1111.     waddch(w,wr);
  1112.     wmove(w,w->_width_y-1,i);
  1113.     waddch(w,wr);   /* Rand unten */
  1114.   }
  1115.   for(i=1 ; i < w->_width_y-1 ; i++)
  1116.   {
  1117.     wmove(w,i,0);    /* Rand links */
  1118.     waddch(w,sr);
  1119.     wmove(w,i,w->_width_x-1);
  1120.     waddch(w,sr);   /* Rand rechts */
  1121.   }
  1122.   w->_scrflag = old_scroll;
  1123. }
  1124.  
  1125. /******************************************************************************
  1126. *
  1127. * Funktion     : Zeichen aus Fenster lesen (winch)
  1128. * --------------
  1129. *
  1130. * Parameter    : w           :
  1131. *                  Typ          : WINDOW *
  1132. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1133. *                  Bedeutung    : Fenster, aus dem gelesen werden soll
  1134. *
  1135. * Ergebnis     :
  1136. *                  Typ          : short int
  1137. *                  Wertebereich : '\0' - MAXINT
  1138. *                  Bedeutung    : Zeichen samt Attributen, das an der
  1139. *                                 angegebenen Position steht
  1140. *
  1141. * Beschreibung : Im gewünschten Fenster wird an der aktuellen Position
  1142. *                mit cur_to_poi das dort befindliche Zeichen samt Attributen
  1143. *                ermittelt und zurückgegeben.
  1144. *
  1145. ******************************************************************************/
  1146.  
  1147. short int winch(w)
  1148. WINDOW *w;
  1149. {
  1150.   return(*cur_to_poi(w));
  1151. }
  1152.